// ai.js
const { aiApi } = require('../../utils/api.js')

Page({
  data: {
    showChatHistory: false,
    chatMessages: [],
    userQuestion: '',
    isLoading: false,
    showFaceConsultation: false,
    showTongueConsultation: false,
    cameraContext: null,
    faceImagePath: '',
    tongueImagePath: '',
    sublingualImagePath: '',
    isAnalyzing: false,
    analysisResult: null,
    currentPhotoType: 'face' // face, tongue, sublingual
  },

  onLoad() {
    console.log('AI页面加载')
  },

  onUnload() {
    // 清理相机资源
    if (this.data.cameraContext) {
      this.data.cameraContext.stop()
    }
  },

  // 输入问题
  onQuestionInput(e) {
    const value = e.detail.value
    this.setData({
      userQuestion: value
    })
    
    // 可以在这里添加字符计数或其他输入反馈
    if (value.length > 400) {
      wx.showToast({
        title: `还可以输入${500 - value.length}个字符`,
        icon: 'none',
        duration: 1000
      })
    }
  },

  // 发送问题到AI
  async onSendQuestion() {
    const question = this.data.userQuestion.trim()
    if (!question) {
      wx.showToast({
        title: '请输入问题',
        icon: 'none'
      })
      return
    }

    this.setData({
      isLoading: true,
      showChatHistory: true
    })

    // 添加用户消息
    this.addMessage('user', question)
    
    // 清空输入框
    this.setData({
      userQuestion: ''
    })

    try {
      // 调用SpringAI接口并模拟流式输出
      await this.callAIWithStream(question)
    } catch (error) {
      console.error('AI调用失败:', error)
      this.addMessage('ai', '抱歉，AI服务暂时不可用，请稍后再试。')
    } finally {
      this.setData({
        isLoading: false
      })
    }
  },

  // 模拟流式输出的AI调用
  async callAIWithStream(message) {
    try {
      // 先获取完整的AI回复
      const fullResponse = await this.callAI(message)
      
      // 添加一个空的AI消息作为占位符
      const messageId = Date.now()
      const messages = this.data.chatMessages
      messages.push({
        id: messageId,
        type: 'ai',
        content: '',
        time: this.getCurrentTime(),
        isStreaming: true
      })
      this.setData({
        chatMessages: messages
      })

      // 模拟逐字显示效果
      await this.simulateStreaming(fullResponse, messageId)
      
    } catch (error) {
      throw error
    }
  },

  // 模拟流式显示文本
  async simulateStreaming(text, messageId) {
    const messages = this.data.chatMessages
    const messageIndex = messages.findIndex(msg => msg.id === messageId)
    
    if (messageIndex === -1) return

    let currentText = ''
    const chars = text.split('')
    
    for (let i = 0; i < chars.length; i++) {
      currentText += chars[i]
      
      // 更新消息内容
      messages[messageIndex].content = currentText
      this.setData({
        chatMessages: messages
      })
      
      // 根据字符类型调整延迟时间，使显示更自然
      let delay = 30 // 默认延迟
      const char = chars[i]
      
      if (char === '。' || char === '！' || char === '？' || char === '\n') {
        delay = 200 // 句号、感叹号、问号、换行后稍长停顿
      } else if (char === '，' || char === '；' || char === '：') {
        delay = 100 // 逗号、分号、冒号后短停顿
      } else if (char === ' ') {
        delay = 20 // 空格快速显示
      } else if (/[a-zA-Z0-9]/.test(char)) {
        delay = 25 // 英文和数字稍快
      }
      
      await this.delay(delay)
    }
    
    // 标记流式输出完成
    messages[messageIndex].isStreaming = false
    this.setData({
      chatMessages: messages
    })
  },

  // 延迟函数
  delay(ms) {
    return new Promise(resolve => setTimeout(resolve, ms))
  },

  // 调用AI接口（流式输出）
  async callAIStream(message) {
    const url = 'http://localhost:8899/ai/stream'
    console.log('调用AI流式接口，URL:', url, '消息:', message)
    
    return new Promise((resolve, reject) => {
      const requestTask = wx.request({
        url: url,
        method: 'GET',
        data: {
          message: message
        },
        success: (res) => {
          console.log('AI流式接口响应:', res)
          if (res.statusCode === 200) {
            resolve(res.data)
          } else {
            reject(new Error(`请求失败: ${res.statusCode}`))
          }
        },
        fail: (err) => {
          console.error('AI流式接口请求失败:', err)
          reject(err)
        }
      })
      
      // 监听数据接收
      requestTask.onHeadersReceived((res) => {
        console.log('接收到响应头:', res)
      })
    })
  },

  // 调用AI接口（普通方式，作为备用）
  async callAI(message) {
    const url = 'http://localhost:8899/ai/generate'
    console.log('调用AI接口，URL:', url, '消息:', message)
    
    return new Promise((resolve, reject) => {
      wx.request({
        url: url,
        method: 'GET',
        data: {
          message: message
        },
        success: (res) => {
          console.log('AI接口响应:', res)
          if (res.statusCode === 200) {
            resolve(res.data)
          } else {
            reject(new Error(`请求失败: ${res.statusCode}`))
          }
        },
        fail: (err) => {
          console.error('AI接口请求失败:', err)
          reject(err)
        }
      })
    })
  },

  // AI聊天相关方法
  onStartChat() {
    wx.showModal({
      title: 'AI中医助手',
      content: '欢迎使用AI中医助手！我可以帮您解答中医相关问题，包括穴位知识、症状诊断、方剂推荐等。',
      confirmText: '开始对话',
      cancelText: '稍后再说',
      success: (res) => {
        if (res.confirm) {
          this.setData({
            showChatHistory: true
          })
          // 添加欢迎消息
          this.addMessage('user', '你好，我想咨询一些中医问题')
          this.addMessage('ai', '您好！我是AI中医助手，很高兴为您服务。请告诉我您想了解什么中医知识，我会尽力为您解答。')
        }
      }
    })
  },

  // 接口自检功能已移除

  async onSymptomCheck() {
    this.setData({
      showChatHistory: true,
      isLoading: true
    })
    
    const question = '我想进行症状诊断，请告诉我需要提供哪些信息？'
    this.addMessage('user', question)
    
    try {
      await this.callAIWithStream(question)
    } catch (error) {
      console.error('AI调用失败:', error)
      this.addMessage('ai', '好的，请详细描述您的症状，包括：\n1. 主要不适症状\n2. 症状持续时间\n3. 是否有诱因\n4. 其他相关症状\n我会根据中医理论为您分析。')
    } finally {
      this.setData({
        isLoading: false
      })
    }
  },


  async onAcupointHelp() {
    this.setData({
      showChatHistory: true,
      isLoading: true
    })
    
    const question = '我想了解穴位知识，请告诉我需要提供哪些信息？'
    this.addMessage('user', question)
    
    try {
      await this.callAIWithStream(question)
    } catch (error) {
      console.error('AI调用失败:', error)
      this.addMessage('ai', '好的，请告诉我您想了解哪个穴位，或者您有什么不适症状需要按摩哪些穴位。我会为您详细介绍穴位的功效、位置和按摩方法。')
    } finally {
      this.setData({
        isLoading: false
      })
    }
  },

  onCloseChatHistory() {
    this.setData({
      showChatHistory: false
    })
  },

  // 添加消息到聊天记录
  addMessage(type, content) {
    const messages = this.data.chatMessages
    const newMessage = {
      id: Date.now(),
      type: type,
      content: content,
      time: this.getCurrentTime()
    }
    messages.push(newMessage)
    this.setData({
      chatMessages: messages
    })
  },

  // 获取当前时间
  getCurrentTime() {
    const now = new Date()
    const hours = now.getHours().toString().padStart(2, '0')
    const minutes = now.getMinutes().toString().padStart(2, '0')
    return `${hours}:${minutes}`
  },

  // ========== 面诊功能相关方法 ==========
  
  // 开始面诊
  onStartFaceConsultation() {
    this.setData({
      showFaceConsultation: true,
      currentPhotoType: 'face'
    })
    
    // 初始化相机
    this.initCamera()
  },

  // 开始舌诊
  onStartTongueConsultation() {
    this.setData({
      showTongueConsultation: true,
      currentPhotoType: 'tongue'
    })
    
    // 初始化相机
    this.initCamera()
  },

  // 初始化相机
  initCamera() {
    const cameraContext = wx.createCameraContext()
    this.setData({
      cameraContext: cameraContext
    })
  },

  // 拍照
  onTakePhoto() {
    if (!this.data.cameraContext) {
      wx.showToast({
        title: '相机未初始化',
        icon: 'none'
      })
      return
    }

    this.data.cameraContext.takePhoto({
      quality: 'high',
      success: (res) => {
        console.log('拍照成功:', res.tempImagePath)
        
        const currentType = this.data.currentPhotoType
        const updateData = {}
        updateData[`${currentType}ImagePath`] = res.tempImagePath
        this.setData(updateData)
        
        // 根据当前拍照类型决定下一步操作
        if (this.data.showTongueConsultation) {
          this.handleTonguePhoto(currentType, res.tempImagePath)
        } else {
          // 普通面诊，直接分析
          this.analyzeFace(res.tempImagePath)
        }
      },
      fail: (err) => {
        console.error('拍照失败:', err)
        wx.showToast({
          title: '拍照失败，请重试',
          icon: 'none'
        })
      }
    })
  },

  // 处理舌诊拍照
  handleTonguePhoto(photoType, imagePath) {
    if (photoType === 'tongue') {
      // 拍完舌照，询问是否拍舌下脉络照
      wx.showModal({
        title: '拍照完成',
        content: '舌照拍摄完成，是否继续拍摄舌下脉络照？',
        confirmText: '继续',
        cancelText: '开始分析',
        success: (res) => {
          if (res.confirm) {
            this.setData({
              currentPhotoType: 'sublingual'
            })
            wx.showToast({
              title: '请拍摄舌下脉络照',
              icon: 'none'
            })
          } else {
            // 开始分析
            this.analyzeTongue(this.data.tongueImagePath)
          }
        }
      })
    } else if (photoType === 'sublingual') {
      // 拍完舌下脉络照，开始分析
      this.analyzeTongue(this.data.tongueImagePath, this.data.sublingualImagePath)
    }
  },

  // 切换相机
  onSwitchCamera() {
    // 微信小程序相机组件会自动处理前后摄像头切换
    wx.showToast({
      title: '已切换摄像头',
      icon: 'none',
      duration: 1000
    })
  },

  // 分析面部（直接使用本地图片）
  async analyzeFace(imagePath) {
    this.setData({
      isAnalyzing: true
    })

    try {
      // 直接调用AI分析接口，传递本地图片路径
      const analysisResult = await aiApi.analyzeFace(imagePath)
      
      this.setData({
        analysisResult: analysisResult,
        isAnalyzing: false
      })
      
      // 显示分析结果（如果为空则走模拟）
      this.showAnalysisResult(analysisResult)
    } catch (error) {
      console.error('面部分析失败:', error)
      this.setData({
        isAnalyzing: false
      })
      
      // 显示模拟分析结果
      this.showMockAnalysisResult()
    }
  },

  // 分析舌诊（直接使用本地图片）
  async analyzeTongue(tongueImagePath, sublingualImagePath = null) {
    this.setData({
      isAnalyzing: true
    })

    try {
      // 直接调用舌诊API，传递本地图片路径
      const analysisResult = await aiApi.analyzeTongue(null, tongueImagePath, sublingualImagePath)
      
      this.setData({
        analysisResult: analysisResult,
        isAnalyzing: false
      })
      
      // 显示分析结果
      this.showTongueAnalysisResult(analysisResult)
      
    } catch (error) {
      console.error('舌诊分析失败:', error)
      this.setData({
        isAnalyzing: false
      })
      
      // 显示模拟舌诊结果
      this.showMockTongueAnalysisResult()
    }
  },

  // 注释：已删除不再需要的uploadFaceImage和callFaceAnalysisAPI函数
  // 现在直接使用本地图片路径调用API

  // 显示分析结果
  showAnalysisResult(result) {
    // 检查result是否为null或undefined
    if (!result) {
      console.warn('分析结果为空，使用模拟结果')
      this.showMockAnalysisResult()
      return
    }
    
    // 处理阿里云舌面诊API返回的数据
    if (result.code === 20000 && result.success && result.data) {
      const data = result.data
      const analysis = this.parseAlibabaAnalysisData(data)
      
      // 构造诊断数据
      const diagnosisData = {
        mainDiagnosis: data.syndrome_name || '淡白无华:气血不足或失血证',
        detailedExplanation: data.physique_analysis || '脾胃为后天之本,气血生化之源,脾胃气虚,不能运化水谷,化生气血,气血不足,面部不能被气血荣润而见淡白;或者是由于失血更多',
        eyeColor: {
          status: '正常',
          explanation: '眼眶周围发青发黑,常因久病体虚、睡眠不足、烟酒刺激等生活规律不正常而引起的。因此,预防黑眼圈必须保证每天7~9小时充更多'
        }
      }
      
      // 跳转到面诊详情页面
      wx.navigateTo({
        url: `/pages/face-diagnosis-detail/face-diagnosis-detail?diagnosisData=${encodeURIComponent(JSON.stringify(diagnosisData))}`
      })
    } else {
      // 处理错误情况，显示模拟结果
      this.showMockAnalysisResult()
    }
  },

  // 解析阿里云舌面诊分析数据
  parseAlibabaAnalysisData(data) {
    // 处理特征分析
    let featuresText = ''
    if (data.features && data.features.length > 0) {
      featuresText = data.features.map(feature => {
        const status = feature.feature_situation === '异常' ? '⚠️' : '✅'
        return `• ${status} ${feature.feature_group}：${feature.feature_name} (${feature.feature_situation})`
      }).join('\n')
    } else {
      featuresText = '• 暂无特征分析数据'
    }

    // 处理调理建议
    let advicesText = ''
    if (data.advices) {
      const adviceTypes = []
      
      if (data.advices.food && data.advices.food.length > 0) {
        adviceTypes.push('🍎 饮食建议：' + data.advices.food.map(f => f.advice).join('；'))
      }
      
      if (data.advices.sport && data.advices.sport.length > 0) {
        adviceTypes.push('🏃 运动建议：' + data.advices.sport.map(s => s.advice).join('；'))
      }
      
      if (data.advices.sleep && data.advices.sleep.length > 0) {
        adviceTypes.push('😴 起居建议：' + data.advices.sleep.map(s => s.advice).join('；'))
      }
      
      if (data.advices.music && data.advices.music.length > 0) {
        adviceTypes.push('🎵 音乐建议：' + data.advices.music.map(m => m.advice).join('；'))
      }
      
      if (data.advices.treatment && data.advices.treatment.length > 0) {
        adviceTypes.push('💆 外治建议：' + data.advices.treatment.map(t => t.advice).join('；'))
      }
      
      advicesText = adviceTypes.length > 0 ? adviceTypes.join('\n') : '• 暂无调理建议'
    } else {
      advicesText = '• 暂无调理建议'
    }

    return {
      featuresText,
      advicesText
    }
  },

  // 解析面部分析数据（保留兼容性）
  parseFaceAnalysisData(data) {
    // 获取概率最高的结果
    const getHighestProbability = (obj) => {
      let maxKey = ''
      let maxValue = 0
      for (const [key, value] of Object.entries(obj)) {
        if (value > maxValue) {
          maxValue = value
          maxKey = key
        }
      }
      return maxKey
    }

    const faceColor = getHighestProbability(data.faceColor || {})
    const lipColor = getHighestProbability(data.lipColor || {})
    const lipWater = getHighestProbability(data.lipWater || {})
    const nose = getHighestProbability(data.nose || {})
    const hair = getHighestProbability(data.hair || {})
    const leftBanDian = getHighestProbability(data.leftBanDian || {})
    const leftCuoChuang = getHighestProbability(data.leftCuoChuang || {})
    const rightBanDian = getHighestProbability(data.rightBanDian || {})
    const rightCuoChuang = getHighestProbability(data.rightCuoChuang || {})

    // 根据分析结果生成中医建议
    const suggestions = this.generateTCMSuggestions({
      faceColor, lipColor, lipWater, nose, hair,
      leftBanDian, leftCuoChuang, rightBanDian, rightCuoChuang
    })

    return {
      faceColor,
      lipColor,
      lipWater,
      nose,
      hair,
      leftBanDian,
      leftCuoChuang,
      rightBanDian,
      rightCuoChuang,
      suggestions
    }
  },

  // 生成中医建议
  generateTCMSuggestions(analysis) {
    let suggestions = []

    // 面色分析
    if (analysis.faceColor === '白色') {
      suggestions.push('面色偏白，可能存在气血不足，建议多食用红枣、枸杞、当归等补血食材')
    } else if (analysis.faceColor === '红色') {
      suggestions.push('面色偏红，可能存在内热，建议多食用清热降火的食物，如绿豆、冬瓜等')
    } else if (analysis.faceColor === '黄色') {
      suggestions.push('面色偏黄，可能存在脾胃虚弱，建议调理脾胃，多食用山药、薏米等')
    }

    // 唇色分析
    if (analysis.lipColor === '淡白') {
      suggestions.push('唇色淡白，可能存在血虚，建议补血养气')
    } else if (analysis.lipColor === '深红') {
      suggestions.push('唇色深红，可能存在内热，建议清热降火')
    }

    // 唇部干裂
    if (analysis.lipWater === '干裂') {
      suggestions.push('唇部干裂，可能存在津液不足，建议多饮水，食用滋阴润燥的食物')
    }

    // 痤疮分析
    if (analysis.leftCuoChuang === '左脸有痤疮' || analysis.rightCuoChuang === '右脸有痤疮') {
      suggestions.push('面部有痤疮，建议清淡饮食，避免辛辣油腻，可尝试清热解毒的食疗方')
    }

    // 斑点分析
    if (analysis.leftBanDian === '左脸有斑点' || analysis.rightBanDian === '右脸有斑点') {
      suggestions.push('面部有斑点，可能与肝郁气滞有关，建议疏肝理气，保持心情舒畅')
    }

    // 发际线分析
    if (analysis.hair === '发际线靠后') {
      suggestions.push('发际线靠后，可能与肾虚有关，建议补肾养发，多食用黑芝麻、核桃等')
    }

    if (suggestions.length === 0) {
      suggestions.push('面部状态良好，建议继续保持健康的生活习惯，适量运动，规律作息')
    }

    return suggestions.join('\n• ')
  },

  // 显示舌诊分析结果
  showTongueAnalysisResult(result) {
    // 构造舌诊数据
    const diagnosisData = {
      mainDiagnosis: '舌质淡红，苔薄白:脾胃虚弱证',
      detailedExplanation: '舌质淡红表示气血不足，苔薄白提示脾胃虚弱，运化功能减退。建议调理脾胃，补益气血。',
      eyeColor: {
        status: '正常',
        explanation: '舌体形态正常，无明显的瘀斑或裂纹，提示脏腑功能基本正常。'
      }
    }
    
    // 跳转到面诊详情页面
    wx.navigateTo({
      url: `/pages/face-diagnosis-detail/face-diagnosis-detail?diagnosisData=${encodeURIComponent(JSON.stringify(diagnosisData))}`
    })
  },

  // 显示模拟面诊分析结果
  showMockAnalysisResult() {
    const diagnosisData = {
      mainDiagnosis: '淡白无华:气血不足或失血证',
      detailedExplanation: '脾胃为后天之本,气血生化之源,脾胃气虚,不能运化水谷,化生气血,气血不足,面部不能被气血荣润而见淡白;或者是由于失血更多',
      eyeColor: {
        status: '正常',
        explanation: '眼眶周围发青发黑,常因久病体虚、睡眠不足、烟酒刺激等生活规律不正常而引起的。因此,预防黑眼圈必须保证每天7~9小时充更多'
      }
    }
    
    // 跳转到面诊详情页面
    wx.navigateTo({
      url: `/pages/face-diagnosis-detail/face-diagnosis-detail?diagnosisData=${encodeURIComponent(JSON.stringify(diagnosisData))}`
    })
  },

  // 显示模拟舌诊分析结果
  showMockTongueAnalysisResult() {
    const diagnosisData = {
      mainDiagnosis: '舌质淡红，苔薄白:脾胃虚弱证',
      detailedExplanation: '舌质淡红表示气血不足，苔薄白提示脾胃虚弱，运化功能减退。建议调理脾胃，补益气血。',
      eyeColor: {
        status: '正常',
        explanation: '舌体形态正常，无明显的瘀斑或裂纹，提示脏腑功能基本正常。'
      }
    }
    
    // 跳转到面诊详情页面
    wx.navigateTo({
      url: `/pages/face-diagnosis-detail/face-diagnosis-detail?diagnosisData=${encodeURIComponent(JSON.stringify(diagnosisData))}`
    })
  },

  // 关闭面诊界面
  onCloseFaceConsultation() {
    this.setData({
      showFaceConsultation: false,
      showTongueConsultation: false,
      faceImagePath: '',
      tongueImagePath: '',
      sublingualImagePath: '',
      analysisResult: null,
      isAnalyzing: false,
      currentPhotoType: 'face'
    })
    
    // 停止相机
    if (this.data.cameraContext) {
      this.data.cameraContext.stop()
    }
  },

  // 重新拍照
  onRetakePhoto() {
    this.setData({
      faceImagePath: '',
      analysisResult: null,
      isAnalyzing: false
    })
  },

  // 相机错误处理
  onCameraError(e) {
    console.error('相机错误:', e)
    wx.showModal({
      title: '相机错误',
      content: '无法访问相机，请检查权限设置',
      showCancel: false,
      confirmText: '确定'
    })
  }
})
